local desc_hx__1v2 = [[
  # 2欢乐斗地主模式简介
 
  ## 倍率框来自水天一色大佬~

  ## 与欢乐斗地主的区别是农民手牌互相可见，且可抢地主（人机默认不参与），也会显示是谁在选择倍率。

  ## 新增换将卡，房主可在游戏开始前选择换将次数

  手杀武将占比超过一半，地主将获得技能“强易”（强易：每名角色限一次，出牌阶段，你可以获得一名其他角色一张牌然后交给其一张牌。）。

  <b>加入金豆机制：</b>

  第一次游玩会获得1000金豆，用于循环抢地主，金豆为负数时无法抢地主！注意，<b>存在人机且开启自由选将时金豆不会改变！</b>

  每次选择将消耗对应数量的金豆，当<b>同一轮循环的“取消”被点击两次及以上时才会停止循环</b>（仅一名玩家时无循环，点击“取消”为随机地主），然后金豆消耗最多的玩家将成为地主。

  金豆会在对局结束时正式结算，胜利的玩家将返还所有金豆，失败的玩家则会将消耗的金豆分配（向上取整）给胜利的玩家。

  破产（即金豆为负数）后将不会再扣除金豆，且每局金豆结算后将获得100金豆。

  <b>下面是欢乐斗地主的规则：</b>

  总体规则类似身份局。游戏由三人进行，一人扮演地主（主公），其他两人扮演农民（反贼）。

  地主选将框+2，增加1点体力上限和体力，且拥有以下额外技能：

  - **飞扬**：判定阶段开始时，你可以弃置两张手牌并弃置自己判定区内的一张牌。

  - **跋扈**：锁定技，准备阶段，你摸一张牌；出牌阶段，你可以多使用一张【杀】。

  当农民被击杀后，另一名农民可以选择：摸两张牌，或者回复1点体力。

  *击杀农民的人没有摸三张牌的奖励。*

  胜利规则与身份局一致。

]]

--[[
迷你、game机制分析
loadData 跟普通对话框差不多
通过ClientInstance.notifyServer("PushRequest", "updatemini,select," + root.selected);
这个返回调用minigame的 update_func，弃置data是用逗号隔开的select，等
然后大概是用更新doNotify("UpdateMiniGame", json.encode(data))
--]]

-- 对该qml及MiniGame的理解
-- 调用MiniGame时会将服务端的信息传给qml，qml会先处理所有键值表，但是能点击按钮的只有一个，
-- 然后要在addMiniGame里设置更新下一个可以点按钮的角色并传给qml，然后两边的信息是用json传递的，所以同样要用json才能得到数据。
-- 另外，qml如果得到了3倍的信息就会直接关闭，所以要想达到通知哪个角色选择了几倍的效果，最好是直接写在qml里。
-- 然而我发现写在qml却只有第一个选倍率的人能看到。。toast.show似乎不怎么管用，于是我发现了另一个方法，即下面的在update_func里和开始miniGame时通知。

---2025.8.4，json被杀了。像这种json，直接杀掉。

local HX = require "packages/huixiangkill/hxfs"

Fk:addMiniGame {
  name = "hx__1v2_selectdizhu",
  qml_path = "packages/huixiangkill/qml/ChooseGeneralfor1v2",
  default_choice = function(player, data) --默认值
    return 1
  end,
  update_func = function(player, data)
    local room = player.room
    local b = player.next._splayer:getScreenName()
    local pname = player._splayer:getScreenName()
    local x = data
    local n
    if type(x) == "table" and #x >= 2 then
      n = tonumber(x[2]) or 1
    end
    n = n * 100
    local num = room:getBanner("@hx__1v2_mode_POINT") or 0
    num = num + n
    if n ~= 100 then
      room:broadcastPlaySound("./packages/huixiangkill/audio/skill/1v2__"..n)
      room:sendLog{ type = ""..pname.."选择了加注"..n.."金豆" }
    else
      room:sendLog{ type = ""..pname.."选择了不加注" }
    end
    for _, p in ipairs(room.players) do
      p:doNotify("UpdateMiniGame", data)
      if n ~= 100 then
        p:doNotify("ShowToast", ""..pname.."选择了加注"..n.."金豆")
      else
        p:doNotify("ShowToast", ""..pname.."选择了不加注")
      end
      p:doNotify("ShowToast", "当前正在选择倍率的玩家是"..b.."")
    end
  end,
}

Fk:addMiniGame {
  name = "ChooseGeneralWithCanChange",
  qml_path = "packages/huixiangkill/qml/ChooseGeneralWithCanChange",
  default_choice = function(player, data) --默认值
    return table.random(data.cards, data.num)
  end,
  update_func = function(player, data)
    player:doNotify("UpdateMiniGame", data)
  end,
}

local hx__1v2_getLogic = function()
  local hx__1v2_logic = GameLogic:subclass("hx__1v2_logic")

  function hx__1v2_logic:initialize(room)
    GameLogic.initialize(self, room)
    self.role_table = { nil, nil, { "lord", "rebel", "rebel" }, }
  end

  function hx__1v2_logic:assignRoles()
    local room = self.room
    local n = #room.players
    room:setBanner("@[:]huixiangmode_rule","hx__1v2-intro")
    local roles = self.role_table[n]
    table.shuffle(roles)

    for i = 1, n do
      local p = room.players[i]
      p.role = roles[i]
    end

    for _, p in ipairs(room.players) do
      room:setPlayerProperty(p, "role_shown", true)
      room:broadcastProperty(p, "role")
    end

  end

  function hx__1v2_logic:adjustSeats()
    local player_circle = {}
    local room = self.room
    local players = self.room.players
    local p = 1
    for i = 1, #players do
      if players[i].role == "lord" then
        p = i
        break
      end
    end
    for j = p, #players do
      table.insert(player_circle, players[j])
    end
    for j = 1, p - 1 do
      table.insert(player_circle, players[j])
    end

    self.room:arrangeSeats(player_circle)
  end

  function hx__1v2_logic:chooseGenerals()
    local room = self.room ---@type Room
    local generalNum = room.settings.generalNum
    local n = room.settings.enableDeputy and 2 or 1
    local players = room.players
    local lord
    for _, p in ipairs(players) do
      if p.role == "lord" then
        lord = p
      end
    end
    room:setCurrent(lord)

    local nonlord = table.filter(players, function(p) return p.id ~= lord.id end)
    local generals = table.map(Fk:getGeneralsRandomly(#players * generalNum), Util.NameMapper)
    table.shuffle(generals)
    local t1 = table.slice(generals, 1, generalNum + 1)
    local t2 = table.slice(generals, generalNum + 1, generalNum * 2 + 1)
    local dizhu = table.slice(generals, generalNum * 2 + 1, generalNum * 3 + 1)

    local data_table = {
      [nonlord[1].id] = {
       friend_id = nonlord[2].id,
       me = t1, friend = t2,
       change = {},
      },
      [nonlord[2].id] = {
       friend_id = nonlord[1].id,
       me = t2, friend = t1,
       change = {},
      },
      [lord.id] = {
        change = {},
        cards = dizhu, num = n,
        no_c = false, heg = false,
        type = "askForGeneralsChosen",
        extra = {n = n},
      },
    }

    local game = Fk.mini_games["hx__2v2_sel"]
    local req = Request:new(players,"MiniGame")
    req.focus_text = "AskForGeneral"
    req.receive_decode = false
    req.timeout = room.settings.generalTimeout

    for _, p in ipairs(nonlord) do
      local data = data_table[p.id]
      p.mini_game_data = { type = "hx__2v2_sel", data = data }
      req:setData(p, p.mini_game_data)
      req:setDefaultReply(p, game.default_choice and game.default_choice(p, data))
    end
    local data = data_table[lord.id]
    game = Fk.mini_games["ChooseGeneralWithCanChange"]
    lord.mini_game_data = { type = "ChooseGeneralWithCanChange", data = data }
    req:setData(lord, lord.mini_game_data)
    req:setDefaultReply(lord, game.default_choice and game.default_choice(lord, data))

    req:ask()
    for _, p in ipairs(players) do
      p.mini_game_data = nil
    end

    for _, p in ipairs(players) do
      local result = p.client_reply
      if p.id ~= lord.id then
        room:prepareGeneral(p, result)
      else
        room:prepareGeneral(p, result[1], result[2])
      end
    end
    room:askToChooseKingdom(players)

    nonlord[1]:addBuddy(nonlord[2])
    nonlord[2]:addBuddy(nonlord[1])

  end

  function hx__1v2_logic:attachSkillToPlayers()
    local room = self.room
    local addRoleModSkills = function(player, skillName)
      local skill = Fk.skills[skillName]
      if not skill then
        fk.qCritical("Skill: " .. skillName .. " doesn't exist!")
        return
      end
      if skill:hasTag(Skill.Lord) then
        return
      end
      if skill:hasTag(Skill.AttachedKingdom) and not table.contains(skill:getSkeleton().attached_kingdom, player.kingdom) then
        return
      end
      room:handleAddLoseSkills(player, skillName, nil, false)
    end
    for _, p in ipairs(room.alive_players) do
      for _, s in ipairs(Fk.generals[p.general]:getSkillNameList(false)) do
        addRoleModSkills(p, s)
      end
      local deputy = Fk.generals[p.deputyGeneral]
      if deputy then
        for _, s in ipairs(deputy:getSkillNameList(false)) do
          addRoleModSkills(p, s)
        end
      end
      if p.role == "lord" then
        room:handleAddLoseSkills(p, "m_feiyang|m_bahu", nil, false)
        local mobilegeneral = {}
        for _, general in ipairs(Fk:getAllGenerals()) do
          if general.package.extensionName == "mobile" or general.package.extensionName == "mougong" then
            table.insertIfNeed(mobilegeneral, general)
          end
        end
        if #mobilegeneral / #Fk:getAllGenerals() >= 0.5 then
          room:sendLog{ type = "#hx_1v2_skill_tips", toast = true }
          room:delay(2000)
          room:handleAddLoseSkills(p, "hx_1v2__qiangyi", nil, false)
        end
      end
    end
  end

  return hx__1v2_logic
end


local hx__1v2_mode = fk.CreateGameMode {
  name = "hx__1v2_mode",
  minPlayer = 3,
  maxPlayer = 3,
  logic = hx__1v2_getLogic,
  main_mode = "1v2_mode",
  rule = "#hx__1v2_rule&",
  is_counted = function(self, room)
    return #room.players >= 2
  end,
  surrender_func = function(self, playedTime)
    local surrenderJudge = { { text = "time limitation: 30 min", passed = playedTime >= 30 } }
    if Self.role ~= "lord" then
      table.insert(surrenderJudge, { text = "1v2: left you alive", passed = #Fk:currentRoom().alive_players == 2 })
    end
    return surrenderJudge
  end,
  get_adjusted = function(self, player)
    if player.role == "lord" then
      return { hp = player.hp + 1, maxHp = player.maxHp + 1 }
    end
    return {}
  end,
  reward_punish = function(self, victim, killer)
    local room = victim.room
    if victim.role == "rebel" then
      for _, p in ipairs(room:getOtherPlayers(victim)) do
        if p.role == "rebel" then
          local choices = { "draw2", "Cancel" }
          if p:isWounded() then
            table.insert(choices, 2, "recover")
          end
          local choice = room:askToChoice(p, {
            choices = choices,
            skill_name = "PickLegacy",
          })
          if choice == "draw2" then
            p:drawCards(2, "game_rule")
          else
            room:recover {
              who = p,
              num = 1,
              recoverBy = p,
              skillName = "game_rule",
            }
          end
        end
      end
    end
  end,
}



Fk:addQmlMark{
  name = "hxjindou",
  how_to_show = function(name, value, p)
    if p.id > 0 then
      if p:getMark("@!!hx_1v2_jindou") > 0 then
        return tostring(p:getMark("@!!hx_1v2_jindou"))
      end
      return " "
    end
    return " "
  end,
  qml_path = "packages/huixiangkill/qml/HXjindouBox"
}

local hx__point = [[
  第一次游玩会获得1000金豆，用于循环抢地主，金豆为负数时无法抢地主！<b>存在人机且开启自由选将时金豆不会改变！</b>
  <br>每次选择将消耗对应数量的金豆，当<b>同一轮循环的“取消”被点击两次及以上时才会停止循环</b>（仅一名玩家时无循环，点击“取消”为随机地主），然后金豆消耗最多的玩家将成为地主。
  <br>金豆会在对局结束时正式结算，胜利的玩家将返还所有金豆，失败的玩家则会将消耗的金豆分配（向上取整）给胜利的玩家。
  <br>破产（即金豆为负数）后将不会再扣除金豆，且每局金豆结算后将获得100金豆。
]]

Fk:loadTranslationTable {
  ["hx__1v2_mode"] = "2斗地主",
  ["#hx__1v2_rule"] = "挑选遗产",
  ["hx__1v2-intro"] = "2斗地主",
  [":hx__1v2-intro"] = [[
  <br>总体规则类似身份局。游戏由三人进行，一人扮演地主（主公），其他两人扮演农民（反贼）。

  <br>地主选将框+2，增加1点体力上限和体力，且拥有以下额外技能：

  <br>飞扬：判定阶段开始时，你可以弃置两张手牌并弃置自己判定区内的一张牌。

  <br>跋扈：锁定技，准备阶段，你摸一张牌；出牌阶段，你可以多使用一张【杀】。

  <br>当农民被击杀后，另一名农民可以选择：摸两张牌，或者回复1点体力。

  <br>击杀农民的人没有摸三张牌的奖励。

  <br>胜利规则与身份局一致。

  <br><b>可抢地主（循环抢）且农民手牌互相可见，倍率框来自水天一色大佬（小改了一下）~</b>

  <br>手杀武将占比超过一半，地主将获得技能“强易”（强易：每名角色限一次，出牌阶段，你可以获得一名其他角色一张牌然后交给其一张牌。）。

  <br><b>加入金豆机制：</b>
  <br>第一次游玩会获得1000金豆，用于循环抢地主，金豆为负数时无法抢地主！<b>存在人机且开启自由选将时金豆不会改变！</b>

  <br>每次选择将消耗对应数量的金豆，当<b>同一轮循环的“取消”被点击两次及以上时才会停止循环</b>（仅一名玩家时无循环，点击“取消”为随机地主），然后金豆消耗最多的玩家将成为地主。

  <br>金豆会在对局结束时正式结算，胜利的玩家将返还所有金豆，失败的玩家则会将消耗的金豆分配（向上取整）给胜利的玩家。

  <br>破产（即金豆为负数）后将不会再扣除金豆，且每局金豆结算后将获得100金豆。

  ]],
  ["$LookGeneral"] = "右键或长按可查看武将的技能描述，你有%1金豆，是否加注？",

  ["hx__1v2_selectdizhu"] = "选择地主",
  ["@hx__1v2_mode_POINT"] = "本局金豆",
  [":@[:]hx__1v2_mode_POINT"] = hx__point,

  ["1hx__point-intro"] = "1  倍率说明",
  [":1hx__point-intro"] = hx__point,
  ["2hx__point-intro"] = "2  倍率说明",
  [":2hx__point-intro"] = hx__point,
  ["3hx__point-intro"] = "3  倍率说明",
  [":3hx__point-intro"] = hx__point,

  ["#hx__1v2_mode_findai"] = "本局存在人机，本局金豆未超过100则为随机地主",
  ["#hx_1v2_skill_tips"] = "手杀武将占比超过一半，地主获得技能“强易”！\
  （强易：每名角色限一次，出牌阶段，你可以获得一名其他角色一张牌然后交给其一张牌。）",

  ["$thechoosingplayer"] = "当前正在选择倍率的玩家是 %1",
  ["$thechoosingresult_3"] = "%1 选择了3倍抢地主！",
  ["$thechoosingresult"] = "%1 选择了%2倍",

  ["@!!hx_1v2_jindou"] = "金豆",
  [":@!!hx_1v2_jindou"] = "2斗地主模式抢地主所消耗的道具",
  ["@[hxjindou]hx_1v2_jindou"] = "金豆",
  ["@!!hx_1v2__ling"] = "招募令",
  [":@!!hx_1v2__ling"] = "2斗地主模式胜利后才能获得的道具，强者的象征",

  ["#hx_1v2_initMoney"] = "提示：正在初始化金豆，请稍候~",
  ["#hx_1v2_changeMoney"] = "提示：正在结算金豆中，请勿退出",
  ["#hx_1v2_changeMoneyOver"] = "金豆结算完成！",

  [":hx__1v2_mode"] = desc_hx__1v2,
}

return hx__1v2_mode